#ifndef __ListaSimple_h__
#define __ListaSimple_h__


/******************************************************************************/
/* Definicion de tipode de datos */
typedef enum 
{
LS_PRIMERO,   //0 
LS_SIGUIENTE, //1
LS_ANTERIOR   //2
} TMovimiento_Ls;

typedef struct TNodoSimple
{
	void* Elem;
	struct TNodoSimple *Siguiente;
} TNodoSimple;

typedef struct
{
	TNodoSimple *Primero, *Corriente;
	int TamanioDato;
	int TamanioLista;
} TListaSimple;


/******************************************************************************/
/* Declaracion de primitivas */

/*
Pre: Ls no fue creada.
Post: Ls creada y vac�a */
void ls_Crear(TListaSimple *pLs);

/* 
Pre: Ls creada.
Post: Ls vac�a.*/
void ls_Vaciar(TListaSimple *pLs);

/**
 * Igual que ls_Vaciar, pero no hace un free del elem.
 */
void ls_VaciarLight(TListaSimple *pLs);

/* 
Pre: Ls creada.
Post: Si Ls tiene elementos devuelve FALSE sino TRUE.*/
int ls_Vacia(TListaSimple Ls);

/* 
Pre: Ls creada y no vac�a.
Post: Se devuelve en E el elemento corriente de la lista.*/
void ls_ElemCorriente(TListaSimple Ls, void** pE);

/**
 * Igual que ls_ElemCorriente, pero no hace un free del elem.
 */
void ls_BorrarCorrienteLight(TListaSimple *pLs);

/* ls_MoverCorriente
Pre: Ls creada y no vac�a.
Post: Si Ls est� vac�a, devuelve FALSE. Sino:
Si M = LS_PRIMERO, el nuevo elemento corriente es el primero. Devuelve TRUE
Si M = LS_SIGUIENTE, el nuevo elemento corriente es el siguiente al
anterior. Si estaba en el �ltimo elemento, devuelve FALSE, sino TRUE.
Si M = LS_ANTERIOR, me muevo hacia atras, devuelve FALSE si ya estaba en el primero. */
int ls_MoverCorriente(TListaSimple *pLs, TMovimiento_Ls M);

/*
Pre: Ls creada y no vac�a.
Post: Se elimin� el elemento corriente, El nuevo elemento es el siguiente o
el anterior si el corriente era el �ltimo elemento.*/
void ls_BorrarCorriente(TListaSimple *pLs);

/* 
Pre: Ls creada.
Post: E se agreg� a la lista y es el actual elemento corriente.
Si M=LS_PRIMERO: se insert� como primero de la lista.
Si M=LS_SIGUIENTE: se insert� despu�s del elemento corriente.
Si M=LS_ANTERIOR: se insert� antes del elemento corriente.
Si pudo insertar el elemento devuelve TRUE, sino FALSE.*/
int ls_Insertar(TListaSimple *pLs, TMovimiento_Ls M, void* E);

/**
 *
 */
int ls_Tamanio(TListaSimple pLs);

#endif
